____ _ _ _ _
| _ \ ___ | |_ (_) _ __ ___ __| | (_) __ _
| |_) | / _ \ | __| | | | '_ \ / _ \ / _| | | | / _ |
| _ < | __/ | |_ | | | |_) | | __/ | (_| | | | | (_| |
|_| \_\ \___| \__| |_| | .__/ \___| \__,_| |_| \__,_|
|_|
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b
ÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻÂŻ
Python (Programmiersprache)
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
top
Python ([], [], auf Deutsch auch []) ist eine universell nutzbare, Ăźblicherweise interpretierte, hĂśhere Programmiersprache.cite-ref-14[14] Sie hat den Anspruch, einen gut lesbaren, knappen Programmierstil zu fĂśrdern.cite-ref-15[15] So werden beispielsweise BlĂścke nicht durch geschweifte Klammern, sondern durch EinrĂźckungen strukturiert.
Python unterstĂźtzt mehrere Programmierparadigmen, z. B. die objektorientierte, die aspektorientierte und die funktionale Programmierung. Ferner bietet es eine dynamische Typisierung. Wie viele dynamische Sprachen wird Python oft als Skriptsprache genutzt. Die Sprache weist ein offenes, gemeinschaftsbasiertes Entwicklungsmodell auf, das durch die gemeinnĂźtzige Python Software Foundation gestĂźtzt wird, die die Definition der Sprache in der Referenzumsetzung CPython pflegt.
Contents
⢠Versionen
⢠Ziele
⢠Sammeltypen
⢠Objektsystem
⢠Syntax
⢠Beispiel
⢠Paketverwaltung
⢠In der Lehre
⢠Kritik
⢠Literatur
⢠Weblinks
⢠Tutorials
⢠Einzelnachweise
ââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââââ
Entwicklungsgeschichte
Die Sprache wurde Anfang der 1990er Jahre von Guido van Rossum am Centrum Wiskunde & Informatica in Amsterdam als Nachfolger fĂźr die Programmier-Lehrsprache ABC entwickelt und war ursprĂźnglich fĂźr das verteilte Betriebssystem Amoeba gedacht.
Der Name geht nicht, wie das Logo vermuten lässt, auf die gleichnamige Schlangengattung Python zurĂźck, sondern bezog sich ursprĂźnglich auf die englische Komikergruppe Monty Python. In der Dokumentation finden sich daher auch einige Anspielungen auf Sketche aus dem Flying Circus.cite-ref-16[16] Trotzdem etablierte sich die Assoziation zur Schlange, was sich unter anderem in der Programmiersprache Cobracite-ref-17[17] sowie dem Python-Toolkit âBoaâcite-ref-18[18] äuĂert. Die erste Vollversion erschien im Januar 1994 unter der Bezeichnung Python 1.0. GegenĂźber frĂźheren Versionen wurden einige Konzepte der funktionalen Programmierung implementiert, die allerdings später wieder aufgegeben wurden.cite-ref-19[19] Von 1995 bis 2000 erschienen neue Versionen, die fortlaufend als Python 1.1, 1.2 etc. bezeichnet wurden.
Python 2.0 erschien am 16. Oktober 2000. Neue Funktionen umfassten eine voll funktionsfähige Garbage Collection (automatische Speicherbereinigung) und die Unterstßtzung fßr den Unicode-Zeichensatz.cite-ref-20[20]
Python 3.0 (auch Python 3000) erschien am 3. Dezember 2008 nach längerer Entwicklungszeit. Es beinhaltete einige tiefgreifende Ănderungen an der Sprache, etwa das Entfernen von Redundanzen bei Befehlssätzen und veralteten Konstrukten. Da Python 3.0 hierdurch teilweise inkompatibel zu frĂźheren Versionen wurde,cite-ref-21[21] beschloss die Python Software Foundation, Python 2.7 parallel zu Python 3 bis Ende 2019 weiter mit neuen Versionen zu unterstĂźtzen (fĂźr Hinweise zur letzten 2er-Version, zum Support-Ende und zur Migration siehe Abschnitt Ende von Python 2).
Versionen
| Version | Patchversion | VerĂśffentlichung | Ende des vollen Supports | Ende der Sicherheitskorrekturen |
|---|---|---|---|---|
| Ăltere Version; nicht mehr unterstĂźtzt: 0.9 | 0.9.9 [ 22 ] | 20. Feb. 1991 | 29. Juli 1993 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.0 | 1.0.4 [ 22 ] | 26. Jan. 1994 | 15. Feb. 1994 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.1 | 1.1.1 [ 22 ] | 11. Okt. 1994 | 10. Nov. 1994 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.2 | | 13. Apr. 1995 [ 22 ] | Unsupported | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.3 | | 13. Okt. 1995 [ 22 ] | Unsupported | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.4 | | 25. Okt. 1996 [ 22 ] | Unsupported | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.5 | 1.5.2 [ 23 ] | 3. Jan. 1998 | 13. Apr. 1999 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 1.6 | 1.6.1 [ 23 ] | 5. Sep. 2000 [ 24 ] | Sep. 2000 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.0 | 2.0.1 [ 25 ] | 16. Okt. 2000 [ 26 ] | 22. Juni 2001 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.1 | 2.1.3 [ 25 ] | 15. Apr. 2001 [ 27 ] | 9. Apr. 2002 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.2 | 2.2.3 [ 25 ] | 21. Dez. 2001 [ 28 ] | 30. Mai 2003 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.3 | 2.3.7 [ 25 ] | 29. Juni 2003 [ 29 ] | 11. März 2008 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.4 | 2.4.6 [ 25 ] | 30. Nov. 2004 [ 30 ] | 19. Dez. 2008 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.5 | 2.5.6 [ 25 ] | 19. Sep. 2006 [ 31 ] | 26. Mai 2011 | |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.6 | 2.6.9 [ 32 ] | 1. Okt. 2008 | 24. Aug. 2010 | 29. Okt. 2013 |
| Ăltere Version; nicht mehr unterstĂźtzt: 2.7 | 2.7.18 [ 33 ] | 3. Juli 2010 | 1. Jan. 2020 | 1. Jan. 2020 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.0 | 3.0.1 [ 25 ] [ 32 ] [ 34 ] | 3. Dez. 2008 | 27. Juni 2009 | 27. Juni 2009 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.1 | 3.1.5 [ 35 ] | 27. Juni 2009 | 12. Juni 2011 | 6. Apr. 2012 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.2 | 3.2.6 [ 36 ] | 20. Feb. 2011 | 13. Mai 2013 | 20. Feb. 2016 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.3 | 3.3.7 [ 37 ] | 29. Sep. 2012 | 8. März 2014 | 29. Sep. 2017 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.4 | 3.4.10 [ 38 ] | 16. März 2014 | 9. Aug. 2017 | 18. März 2019 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.5 | 3.5.10 [ 39 ] | 13. Sep. 2015 | 8. Aug. 2017 | 30. Sep. 2020 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.6 | 3.6.15 [ 40 ] | 23. Dez. 2016 | 24. Dez. 2018 | 23. Dez. 2021 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.7 | 3.7.17 [ 41 ] | 27. Juni 2018 | 27. Juni 2020 | 27. Juni 2023 |
| Ăltere Version; nicht mehr unterstĂźtzt: 3.8 | 3.8.20 [ 42 ] | 14. Okt. 2019 | 3. Mai 2021 | Okt. 2024 |
| Ăltere Version; noch unterstĂźtzt: 3.9 | 3.9.21 [ 43 ] | 5. Okt. 2020 | 17. Mai 2022 | Okt. 2025 |
| Ăltere Version; noch unterstĂźtzt: 3.10 | 3.10.16 [ 44 ] | 4. Okt. 2021 | Mai 2023 | Okt. 2026 |
| Ăltere Version; noch unterstĂźtzt: 3.11 | 3.11.11 [ 45 ] | 24. Okt. 2022 | Mai 2024 | Okt. 2027 |
| Aktuelle Version: 3.12 | 3.12.10 [ 46 ] | 2. Okt. 2023 | Mai 2025 | Okt. 2028 |
| Aktuelle Version: 3.13 | 3.13.1 [ 47 ] | 1. Okt. 2024 | Okt. 2026 | Okt. 2029 |
| Aktuelle Version: 3.14 | 3.14.0 [ 48 ] | 7. Okt. 2025 | Okt. 2027 | Okt. 2030 |
Ziele
Python wurde mit dem Ziel grĂśĂter Einfachheit und Ăbersichtlichkeit entworfen. Dies wird vor allem durch zwei MaĂnahmen erreicht. Zum einen kommt die Sprache mit relativ wenigen SchlĂźsselwĂśrtern aus.cite-ref-49[49] Zum anderen ist die Syntax reduziert und auf Ăbersichtlichkeit optimiert. Dadurch lassen sich Python-basierte Skripte deutlich knapper formulieren als in anderen Sprachen.cite-ref-50[50]
Van Rossum legte bei der Entwicklung groĂen Wert auf eine Standardbibliothek, die Ăźberschaubar und leicht erweiterbar ist. Dies war Ergebnis seiner schlechten Erfahrung mit der Sprache ABC, in der das Gegenteil der Fall ist.cite-ref-51[51] Dieses Konzept ermĂśglicht, in Python Module aufzurufen, die in anderen Programmiersprachen geschrieben wurden, etwa um Schwächen von Python auszugleichen. Beispielsweise kĂśnnen fĂźr zeitkritische Teile in maschinennäheren Sprachen wie C implementierte Routinen aufgerufen werden.cite-ref-52[52] Umgekehrt lassen sich mit Python Module und Plug-ins fĂźr andere Programme schreiben, die die entsprechende UnterstĂźtzung bieten. Dies ist unter anderem bei Blender, Cinema 4D, GIMP, Maya, Nuke, OpenOffice bzw. LibreOffice, PyMOL, SPSS, QGIS oder KiCad der Fall.
Python ist eine Multiparadigmensprache. Das bedeutet, Python zwingt den Programmierer nicht zu einem einzigen Programmierstil, sondern erlaubt, das fßr die jeweilige Aufgabe am besten geeignete Paradigma zu wählen. Objektorientierte und strukturierte Programmierung werden vollständig unterstßtzt, funktionale und aspektorientierte Programmierung werden durch einzelne Elemente der Sprache unterstßtzt. Die Freigabe nicht mehr benutzter Speicherbereiche erfolgt durch Referenzzählung. Datentypen werden dynamisch verwaltet, eine automatische statische Typprßfung wie z. B. bei C++ gibt es nicht. Jedoch unterstßtzt Python ab Version 3.5 optionale Typ-Annotationen, um eine statische Typprßfung mithilfe externer Software, wie zum Beispiel Mypy, zu vereinfachen.cite-ref-53[53]cite-ref-54[54]
Datentypen und Strukturen
Python besitzt eine grĂśĂere Anzahl von grundlegenden Datentypen. Neben der herkĂśmmlichen Arithmetik unterstĂźtzt es transparent auch beliebig groĂe Ganzzahlen und komplexe Zahlen.
Die Ăźblichen Zeichenkettenoperationen werden unterstĂźtzt. Zeichenketten sind in Python allerdings unveränderliche Objekte (wie auch in Java). Daher geben Operationen, die eine Zeichenkette verändern sollen â wie z. B. durch Ersetzen von Zeichen â immer eine neue Zeichenkette zurĂźck.
Trotz der dynamischen Typverwaltung enthält Python eine gewisse Typprßfung. Diese ist strenger als bei Perl, aber weniger strikt als etwa bei Objective CAML. Implizite Umwandlungen nach dem Duck-Typing-Prinzip sind unter anderem fßr numerische Typen definiert, sodass man beispielsweise eine komplexe Zahl mit einer langen Ganzzahl ohne explizite Typumwandlung multiplizieren kann.
Mit dem Format-Operator % gibt es eine implizite Umwandlung eines Objekts in eine Zeichenkette. Der Operator == ßberprßft zwei Objekte auf (Wert-)Gleichheit. Der Operator is ßberprßft die tatsächliche Identität zweier Objekte.cite-ref-55[55]
Sammeltypen
Python besitzt mehrere Sammeltypen, darunter Listen, Tupel, Mengen (Sets) und assoziative Arrays (Dictionaries). Listen, Tupel und Zeichenketten sind Folgen (Sequenzen, Felder) und kennen fast alle die gleichen Methoden: Ăber die Zeichen einer Kette kann man ebenso iterieren wie Ăźber die Elemente einer Liste. AuĂerdem gibt es die unveränderlichen Objekte, die nach ihrer Erzeugung nicht mehr geändert werden kĂśnnen. Listen sind z. B. erweiterbare Felder, wohingegen Tupel und Zeichenketten eine feste Länge haben und unveränderlich sind.
Der Zweck solcher Unveränderlichkeit hängt z. B. mit den Dictionaries zusammen, einem Datentyp, der auch als assoziatives Array bezeichnet wird. Um die Datenkonsistenz zu sichern, mĂźssen die SchlĂźssel eines Dictionary vom Typ âunveränderlichâ sein. Die ins Dictionary eingetragenen Werte kĂśnnen dagegen von beliebigem Typ sein.
Sets sind Mengen von Objekten und in CPython ab Version 2.4 im Standardsprachumfang enthalten. Diese Datenstruktur kann beliebige (paarweise unterschiedliche) Objekte aufnehmen und stellt Mengenoperationen wie beispielsweise Durchschnitt, Differenz und Vereinigung zur VerfĂźgung.
Objektsystem
Das Typsystem von Python ist auf das Klassensystem abgestimmt. Obwohl die eingebauten Datentypen genau genommen keine Klassen sind, kĂśnnen Klassen von einem Typ erben. So kann man die Eigenschaften von Zeichenketten oder WĂśrterbĂźchern erweitern â auch von Ganzzahlen. Python unterstĂźtzt Mehrfachvererbung.
Die Sprache unterstĂźtzt direkt den Umgang mit Typen und Klassen. Typen kĂśnnen ausgelesen (ermittelt) und verglichen werden und verhalten sich wie Objekte â tatsächlich sind die Typen (wie in Smalltalk) selbst ein Objekt. Die Attribute eines Objektes kĂśnnen als WĂśrterbuch extrahiert werden.
Syntax
Eines der Entwurfsziele fßr Python war die gute Lesbarkeit des Quellcodes. Die Anweisungen benutzen häufig englische SchlßsselwÜrter, wo andere Sprachen Symbole einsetzen (z. B. or statt ||). Fßr strukturierte Programmierung besitzt Python die folgenden Elemente:
⢠Schleifen (wiederholte Ausfßhrung):
⢠for ⌠else zur Iteration ßber die Elemente einer Sequenz
⢠while ⌠else zur Wiederholung, solange ein Ausdruck den Boolean-Wert True hat
⢠Verzweigungen (bedingte Ausfßhrung):
⢠if ⌠elif ⌠else fßr bedingte Verzweigungen
⢠Exceptions (Ausfßhrung im Fehlerfall):
⢠try ⌠except ⌠else ⌠finally fßr Ausnahmebehandlungen
⢠with zum Ausfßhren eines Blocks mit einem Kontext-Manager
Im Gegensatz zu vielen anderen Sprachen kÜnnen for- und while-Schleifen einen else-Zweig haben. Dieser wird nur ausgefßhrt, wenn die Schleife vollständig durchlaufen und nicht mittels break, return oder einer Ausnahme abgebrochen wurde.
Strukturierung durch EinrĂźcken
Python benutzt wie Miranda und Haskell EinrĂźckungen als Strukturierungselement. Diese Idee wurde erstmals von Peter J. Landin vorgeschlagen und von ihm off-side rule (âAbseitsregelâ) genannt. In den meisten anderen Programmiersprachen werden BlĂścke durch Klammern oder SchlĂźsselwĂśrter markiert, während unterschiedlich groĂe Leerräume auĂerhalb von Zeichenketten keine spezielle Semantik tragen. Laut van Rossum verhindert EinrĂźckung als Teil der Sprachsyntax Missverständnisse des Programmierers, spart Raum im Vergleich zu EinrĂźckungskonventionen, die Klammern in eine eigene Zeile setzen und setzt Stil-Diskussionen ein Ende.cite-ref-56[56]
Fakultätsfunktion in C:
int factorial(int x) {
if (x <= 1) {
return 1;
}
return x * factorial(x - 1);
}
Die gleiche Funktion in Python:
def factorial(x):
if x <= 1:
return 1
return x * factorial(x - 1)
Es ist jedoch darauf zu achten, die EinrĂźckungen im gesamten Programmtext gleich zu gestalten. Die gemischte Verwendung von Leerzeichen und Tabulatorzeichen kann zu Problemen fĂźhren, da der Python-Interpreter Tabulatoren im Abstand von acht Leerzeichen annimmt. Je nach Konfiguration des Editors kĂśnnen Tabulatoren optisch mit weniger als acht Leerzeichen dargestellt werden, was zu Syntaxfehlern oder ungewollter Programmstrukturierung fĂźhren kann. Als vorbeugende MaĂnahme kann man den Editor Tabulatorzeichen durch eine feste Anzahl von Leerzeichen ersetzen lassen. Die Python-Distribution enthält in der Standardbibliothek das Modul tabnanny, welches die Vermischung von Tabulator- und Leerzeichen zu erkennen und beheben hilft.
Man kann die Fakultätsfunktion aber auch wie in C einzeilig mit ternärem Operator formulieren:
Die Fakultätsfunktion in C:
int factorial(int x) {
return x <= 1 ? 1 : x * factorial(x - 1);
}
Die Fakultätsfunktion in Python:
def factorial(x):
return 1 if x <= 1 else x * factorial(x - 1)
Funktionales Programmieren
Coconutcite-ref-57[57] und andere Erweiterungen erleichtern das funktionale Programmieren in Python. Darßber hinaus lässt sich dies auch mit dem herkÜmmlichen Python realisieren:
Ausdrucksstarke syntaktische Elemente zur funktionalen Programmierung vereinfachen das Arbeiten mit Listen und anderen Sammeltypen. Eine solche Vereinfachung ist die Listennotation, die aus der funktionalen Programmiersprache Haskell stammt; hier bei der Berechnung der ersten fĂźnf Zweierpotenzen:
zahlen = [1, 2, 3, 4, 5]
zweierpotenzen = [2 ** n for n in zahlen]
Weil in Python Funktionen als Argumente auftreten dĂźrfen, kann man auch ausgeklĂźgeltere Konstruktionen ausdrĂźcken, wie den Continuation-Passing Style.
Pythons Schlßsselwort lambda kÜnnte manche Anhänger der funktionalen Programmierung fehlleiten. Solche lambda-BlÜcke in Python kÜnnen nur Ausdrßcke enthalten, aber keine Anweisungen. Damit werden solche Anweisungen generell nicht verwendet, um eine Funktion zurßckzugeben. Die ßbliche Vorgehensweise ist stattdessen, den Namen einer lokalen Funktion zurßckzugeben. Das folgende Beispiel zeigt dies anhand einer einfachen Funktion nach den Ideen von Haskell Brooks Curry:
def add_and_print_maker(x):
def temp(y):
print(f'{x} + {y} = {x + y}')
return temp
Damit ist auch Currying auf einfache Art mĂśglich, um generische Funktionsobjekte auf problemspezifische herunterzubrechen. Hier ein einfaches Beispiel:
def curry(func, known_argument):
return lambda unknown_argument: func(unknown_argument, known_argument)
Wird die curry-Funktion aufgerufen, erwartet diese eine Funktion mit zwei notwendigen Parametern sowie die Parameterbelegung fĂźr den zweiten Parameter dieser Funktion. Der RĂźckgabewert von curry ist eine Funktion, die das Gleiche tut wie func, aber nur noch einen Parameter benĂśtigt.
def stack():
l = []
def pop():
if not is_empty():
return l.pop()
def push(element):
l.append(element)
def is_empty():
return len(l) == 0
return pop, push, is_empty
pop, push, is_empty = stack()
Auf diese Weise erhält man die drei Funktionsobjekte pop, push, is_empty, um den Stack zu modifizieren bzw. auf enthaltene Elemente zu prßfen, ohne dabei auf l direkt zuzugreifen.
Ausnahmebehandlung
Python nutzt ausgiebig die Ausnahmebehandlung (englisch exception handling) als ein Mittel, um Fehlerbedingungen zu testen. Dies ist so weit in Python integriert, dass es teilweise sogar mĂśglich ist, Syntaxfehler abzufangen und zur Laufzeit zu behandeln.
Ausnahmen haben einige Vorteile gegenĂźber anderen beim Programmieren Ăźblichen Verfahren der Fehlerbehandlung (wie z. B. Fehler-RĂźckgabewerte und globale Statusvariablen). Sie sind Thread-sicher und kĂśnnen leicht bis in die hĂśchste Programmebene weitergegeben oder an einer beliebigen anderen Ebene der Funktionsaufruffolge behandelt werden. Der korrekte Einsatz von Ausnahmebehandlungen beim Zugriff auf dynamische Ressourcen erleichtert es zudem, bestimmte auf Race Conditions basierende SicherheitslĂźcken zu vermeiden, die entstehen kĂśnnen, wenn Zugriffe auf bereits veralteten Statusabfragen basieren.
Der Python-Ansatz legt den Einsatz von Ausnahmen nahe, wann immer eine Fehlerbedingung entstehen kĂśnnte. NĂźtzlich ist dieses Prinzip beispielsweise bei der Konstruktion robuster Eingabeaufforderungen:
while True:
num = input("Eine ganze Zahl eingeben: ")
try:
num = int(num)
except ValueError:
print("Eine _Zahl_, bitte!")
else:
break
Dieses Programmstßck fragt den Benutzer so lange nach einer Zahl, bis dieser eine Zeichenfolge eingibt, die sich per int() in eine Ganzzahl konvertieren lässt. Durch die Ausnahmebehandlung wird hier vermieden, dass eine Fehleingabe zu einem Laufzeitfehler fßhrt, der das Programm zum Abbruch zwingt.
Ebenso kann auch das hier nicht berĂźcksichtigte Interrupt-Signal (SIGINT, häufig Strg+C) mittels Ausnahmebehandlung in Python abgefangen und behandelt werden (except KeyboardInterrupt: âŚ).
Standardbibliothek
Die mächtige Standardbibliothek ist eine der grĂśĂten Stärken von Python, wodurch es sich fĂźr viele Anwendungen eignet. Der Ăźberwiegende Teil davon ist plattformunabhängig, so dass auch grĂśĂere Python-Programme oft auf Unix, Windows, macOS und anderen Plattformen ohne Ănderung laufen. Die Module der Standardbibliothek kĂśnnen mit in C oder Python selbst geschriebenen Modulen ergänzt werden.
Die Standardbibliothek ist besonders auf Internetanwendungen zugeschnitten, mit der UnterstĂźtzung einer groĂen Anzahl von Standardformaten und -protokollen (wie MIME und HTTP). Module zur Schaffung grafischer Benutzeroberflächen, zur Verbindung mit relationalen Datenbanken und zur Manipulation regulärer AusdrĂźcke sind ebenfalls enthalten.
Grafische Benutzeroberflächen (GUI)
Mit Hilfe des mitgelieferten Moduls Tkinter kann in Python (wie in Perl und Tcl) schnell eine grafische Benutzeroberfläche (GUI) mit Tk erzeugt werden. Es gibt darßber hinaus eine Vielzahl von weiteren Wrappern von anderen Anbietern. Sie stellen Anbindungen (englisch language bindings) zu GUI-Toolkits wie z. B. PyGTK, PyQt, wxPython, PyObjC und PyFLTK zur Verfßgung.
Neben Tkinter wird auch ein Modul zum Zeichnen von Turtle-Grafiken mitgeliefert.
Beispiel zum Tkinter-Modul
â
Hauptartikel
:
Tkinter
from tkinter import *
fenster = Tk()
fenster.geometry("200x100")
label = Label(fenster, text="Hallo Welt!")
label.pack()
def befehl():
fenster.destroy()
button = Button(fenster, text="OK", command=befehl)
button.pack()
fenster.mainloop()
Weitere Beispiele
Beispiel zum Turtle-Grafik-Modul
import turtle
from turtle import speed, reset, goto
reset()
speed(0)
turtle.x = -200
turtle.y = 200
while turtle.y != -200:
goto(turtle.x, turtle.y)
turtle.x = - turtle.x
turtle.y = - turtle.y
goto(turtle.x, turtle.y)
goto(0, 0)
turtle.y = - turtle.y
turtle.x = - turtle.x
turtle.y -= 5
Weitere Grafiken
Beispiel
Als nicht triviales Beispiel sei hier der kompakte Sortieralgorithmus Quicksort angegeben:
def quicksort(liste):
if len(liste) <= 1:
return liste
pivotelement = liste.pop()
links = [element for element in liste if element < pivotelement]
rechts = [element for element in liste if element >= pivotelement]
return quicksort(links) + [pivotelement] + quicksort(rechts)
Hier ermĂśglicht insbesondere die Listennotation fĂźr die Variablen links und rechts eine kompakte Darstellung. Zum Vergleich eine iterative Formulierung dieser zwei Zeilen:
...
links, rechts = [], [] # leere Listen fĂźr links und rechts anlegen
pivotelement = liste.pop() # das letzte Element aus der Liste nehmen als Referenz
for element in liste: # die restlichen Elemente der Liste durchlaufen ...
if element < pivotelement: # ... und mit dem Pivot-Element vergleichen
links.append(element) # wenn kleiner, dann an linke Liste anhängen
else:
rechts.append(element) # ansonsten, wenn nicht kleiner, dann an rechte Liste anhängen
...
Dies ist nur ein Beispiel fĂźr die gesparte Schreibarbeit durch die Listennotation. Tatsächlich ist in diesem Fall die iterative Formulierung die schnellere, da pro Durchgang nur einmal Ăźber das Feld âlisteâ iteriert wird und nicht zweimal wie in der Listennotation.
Interaktive Benutzung
So wie Lisp, Ruby, Groovy und Perl unterstĂźtzt der Python-Interpreter auch einen interaktiven Modus, in dem AusdrĂźcke am Terminal eingegeben und die Ergebnisse sofort betrachtet werden kĂśnnen. Das ist nicht nur fĂźr Neulinge angenehm, die die Sprache lernen, sondern auch fĂźr erfahrene Programmierer: Code-StĂźckchen kĂśnnen interaktiv ausgiebig getestet werden, bevor man sie in ein geeignetes Programm aufnimmt.
Darßber hinaus steht mit Python Shell ein Kommandozeileninterpreter fßr verschiedene unixoide Computer-Betriebssysteme zur Verfßgung, der neben klassischen Unix-Shellkommandos auch direkte Eingaben in Python-Form verarbeiten kann. IPython ist eine populäre interaktive Python-Shell mit stark erweiterter Funktionalität.
Implementierungen
Interpreter
CPython ist die offizielle oder Referenzimplementierung der Programmiersprache Python und deren Interpreter.
Daneben gibt es einen in Java implementierten Python-Interpreter namens Jython, mit dem die Bibliothek der Java-Laufzeitumgebung fĂźr Python verfĂźgbar gemacht wird.
Compiler
AuĂer den oben genannten Interpretern existieren Compiler, die Python-Code in eine andere Programmiersprache Ăźbersetzen.
Mit Cython kann Python-Code in effiziente C-Erweiterungen Ăźbersetzt oder externer C++- oder C-Code angebunden werden.
Ein Python-Parser fĂźr Parrot und ein in Python geschriebener Just-in-time-Compiler fĂźr Python, PyPy, welcher von der EU gefĂśrdert wurde, sind ebenfalls in Entwicklung.
Auch die Python-Variante Pyston verwendet Just-in-time-Compilierung und beschleunigt so die AusfĂźhrung von Python-Programmen.cite-ref-58[58]
Entwicklungsumgebung
Neben IDLE, das oft mit Python installiert wird und hauptsächlich aus einer Textumgebung und einer Shell besteht, wurden auch einige vollwertige Entwicklungsumgebungen (IDEs) fĂźr Python entwickelt, beispielsweise Eric Python IDE, Spyder oder PyCharm. Weiterhin gibt es Plug-ins fĂźr grĂśĂere IDEs wie Eclipse, Visual Studio, IntelliJ IDEAcite-ref-60[60] und NetBeans. Texteditoren fĂźr Programmierer wie Vim und Emacs lassen sich auch fĂźr Python anpassen: Ein einfacher Python-Mode ist bereits integriert, und komfortablere Erweiterungen kĂśnnen hinzugefĂźgt werden.
Fßr die verschiedenen GUI-Toolkits, wie z. B. Tkinter (GUI-Builder), WxPython (wxGlade), PyQt (Qt Designer), PySide, PyGTK (Glade), Kivy oder PyFLTK gibt es teils eigene Editoren, mit denen sich grafische Benutzeroberflächen auf vergleichsweise einfache Art aufbauen lassen.
Paketverwaltung
Python unterstĂźtzt die Erstellung von Paketen; dabei helfen distutils und setuptools. Die Pakete werden auf PyPI, dem Python Package Index, gespeichert und von dort zur Installation abgerufen. Als Paketmanager wird Ăźblicherweise pip oder auf alten Systemen auch easy_install eingesetzt. Paketversionen der Anaconda (Python-Distribution) werden von der Paketverwaltung conda verwaltet.cite-ref-61[61]
Verbreitung und Einsatz
Python ist fßr die meisten gängigen Betriebssysteme frei erhältlich und bei den meisten Linux-Distributionen im Standardumfang enthalten. Um Python in Webserver einzubinden, wird Webserver-umgreifend WSGI verwendet, welches die Nachteile von CGI umgeht. WSGI stellt eine universelle Schnittstelle zwischen Webserver und Python(-Framework) zur Verfßgung.
Eine Reihe von Web-Application-Frameworks nutzt Python, darunter Django, Pylons, SQLAlchemy, TurboGears, web2py, Flask und Zope. Ferner gibt es einen Python-Interpreter fĂźr das Symbian-Betriebssystem, so dass Python auf verschiedenen Mobiltelefonen verfĂźgbar ist. In der Version 2.5.1 ist Python ein Bestandteil von AmigaOS 4.0.
Kommerzieller Einsatz
Bekannte kommerzielle Projekte, etwa Google Suche und YouTube, basieren in Teilen auf Python.cite-ref-62[62] Auch in der Spieleindustrie findet die Sprache bisweilen Einsatz, etwa in EVE Online, World in Conflict und Civilization IV.
In der Lehre
Python wird gern in der Lehre eingesetzt, da Python auf der einen Seite einsteigerfreundlich ist, auf der anderen Seite aber auch leistungsfähig und mächtig genug, um theoretische Grundlagen der Programmierung zu vermitteln und um moderne Anwendungen bis hin zu komplexen Datenanalysen, grafischer Programmierung oder Datenbankanwendungen zu entwickeln.cite-ref-63[63]cite-ref-64[64]cite-ref-65[65]cite-ref-66[66]cite-ref-67[67]cite-ref-68[68] Lehrbßcher, die sich explizit an junge Menschen ohne Programmiererfahrung wenden, unterstßtzen und unterstreichen diese Entwicklung.cite-ref-69[69]
Im Rahmen des Projektes 100-Dollar-Laptop wird Python als Standardsprache der Benutzeroberfläche verwendet. Da der 100-Dollar-Rechner fĂźr die Schulausbildung von Kindern konzipiert ist, soll bei Benutzung der dafĂźr gestalteten grafischen Benutzeroberfläche âSugarâ auf Knopfdruck der gerade laufende Python-Quellcode angezeigt werden.cite-ref-70[70] Damit soll Kindern die MĂśglichkeit gegeben werden, die dahinter liegende Informationstechnik real zu erleben und nach Belieben âhinter die Kulissenâ zu schauen.
Der Einplatinen-Computer Raspberry Pi (Python Interpreter) sollte ursprĂźnglich mit einem im ROM integrierten Python-Interpreter ausgeliefert werden.cite-ref-71[71] Auch heute ist Python eine der bevorzugtesten Sprachen fĂźr den Raspberry Pi. Sein Standard-Betriebssystem Raspberry Pi OS kommt mit einer groĂen Python-Bibliothek zur Ansteuerung der Hardware.
Python wird weltweit in der Informatikausbildung an Schulen und Universitäten eingesetzt. So steht inzwischen eine Reihe von (kostenlosen) didaktisch konzipierten Online-Lernplattformen zu Python fĂźr Schule und Selbststudium ab dem 6. Schuljahr zur VerfĂźgung â meist in mehreren Sprachen. Der Online-Kurs Computer Science Circles z. B. wird von der Universität Waterloo in Kanada bereitgestellt. Die deutsche Version wird betrieben von den deutschen Bundesweiten Informatikwettbewerben.cite-ref-72[72] TigerJython, gehostet von der Pädagogischen Hochschule Bern, wird vor allem in der Schweiz im Informatikunterricht eingesetzt.cite-ref-73[73]
In der Wissenschaft
In der Wissenschaftsgemeinde genieĂt Python groĂe Verbreitung, hauptsächlich wegen des einfachen Einstiegs in die Programmierung und der groĂen Auswahl wissenschaftlicher Bibliotheken. Oft wird Python hier innerhalb eines Jupyter Notebooks genutzt.cite-ref-74[74] Numerische Rechnungen und die visuelle Aufbereitung der Ergebnisse in Graphen werden meist mit NumPy und der Matplotlib erledigt. Anaconda und SciPy bĂźndeln viele wissenschaftliche Python-Bibliotheken und machen sie somit einfacher zugänglich. Mit TensorFlow, Keras, Scikit-learn, PyTorch u. a. gibt es groĂe Bibliotheken zur Forschung und Nutzung von maschinellem Lernen und Deep Learning (KĂźnstliche Intelligenz).
Ende von Python 2
Die Unterstßtzung fßr Python 2 ist beendet. Die letzte 2er-Version war die 2.7.18 vom 20. April 2020;cite-ref-75[75]cite-ref-76[76] seit diesem Datum wird Python 2 nicht mehr unterstßtzt.cite-ref-77[77]cite-ref-78[78] Es gibt aber vielfältige und umfangreiche Dokumentationen zum Umstiegcite-ref-79[79]cite-ref-80[80]cite-ref-81[81] und auch Tools, die bei der Migration helfencite-ref-82[82] oder es ermÜglichen, Code zu schreiben, der mit Python 2 und 3 funktioniert.cite-ref-83[83]cite-ref-84[84]cite-ref-85[85]cite-ref-86[86]cite-ref-87[87]
Kritik
Bei der Definition von Methoden muss der Parameter self, der der Instanz entspricht, deren Methode aufgerufen wird, explizit als Parameter angegeben werden. Dies wird von Andrew Kuchling, Autor und langjähriger Python-Entwicklercite-ref-88[88], als unelegant und nicht objektorientiert empfunden.cite-ref-kuchlingwarts-89-0[89] Python-SchĂśpfer van Rossum verweist hingegen darauf, dass es nĂśtig sei, um bestimmte wichtige Konstrukte zu ermĂśglichen.cite-ref-90[90] Einer der Python-Grundsätze lautet zudem âExplicit is better than implicitâ.cite-ref-zen-91-0[91]
Bis zur Version 3.0 wurde kritisiert, dass in einer Methodendefinition der Aufruf der Basisklassenversion derselben Methode die explizite Angabe der Klasse und Instanz erfordert. Dies wurde als Verletzung des DRY-Prinzips (âDonât repeat yourselfâ) gesehen; auĂerdem behinderte es Umbenennungen. In Python 3.0 wurde dieser Kritikpunkt behoben.cite-ref-92[92]
Auf Multiprozessor-Systemen behindert der sogenannte Global Interpreter Lock (GIL) von CPython die Effizienz von Python-Anwendungen, die softwareseitiges Multithreading benutzen. Diese Beschränkung existiert unter Jython oder IronPython nicht. Bislang war von offizieller Seite nicht geplant, den GIL zu ersetzen, beginnend mit Version 3.13 kann dieser nun aber mithilfe eines Flags deaktiviert werden.cite-ref-93[93] Alternativ wird empfohlen, mehrere miteinander kommunizierende Prozesse anstelle von Threads zu verwenden.cite-ref-94[94]cite-ref-95[95]
In den vorherrschenden Implementationen ist die Ausfßhrungsgeschwindigkeit niedriger als bei vielen kompilierbaren Sprachen,cite-ref-shootout-c-96-0[96] aber ähnlich wie bei Perl,cite-ref-shootout-perl-97-0[97] PHP,cite-ref-shootout-php-1-98-0[98] Dartcite-ref-shootout-php-2-99-0[99] und Ruby.cite-ref-shootout-ruby-100-0[100] Das liegt zum Teil daran, dass bei der Entwicklung von CPython der Klarheit des Codes gegenßber der Geschwindigkeit Vorrang eingeräumt wird.cite-ref-101[101] Man beruft sich dabei auf Autoritäten wie Donald Knuth und Tony Hoare, die von verfrßhter Optimierung abraten. Wenn Geschwindigkeitsprobleme auftreten, die nicht durch Optimierung des Python-Codes gelÜst werden kÜnnen,cite-ref-102[102] werden stattdessen JIT-Compiler wie PyPy verwendet oder zeitkritische Funktionen in maschinennähere Sprachen wie C oder Cython ausgelagert.
Literatur
FĂźr den Einstieg
⢠Allen B. Downey: Programmieren lernen mit Python. 2. Auflage. OâReilly, KĂśln (u. a.) 2014, ISBN 978-3-95561-806-3, S. 297.
⢠Bernd Klein: Einfßhrung in Python 3. Fßr Ein- und Umsteiger. 4., vollst. ßberarb. Auflage. Hanser, Mßnchen 2021, ISBN 978-3-446-46379-0, S. 600 (Inhaltsverzeichnis).
⢠Thomas Theis: Einstieg in Python. Ideal fßr Programmieranfänger geeignet. 8. Auflage. Rheinwerk Computing, Bonn 2024, ISBN 978-3-367-10123-8, S. 484 (Inhaltsverzeichnis).
⢠Mark Lutz: Learning Python. 6. Auflage. OâReilly, Sebastopol (u. a.) 2025, ISBN 978-1-09-817130-8, S. 1128.
⢠Hans Petter Langtangen: A Primer on Scientific Programming with Python. 5. Auflage. Springer, 2016, ISBN 978-3-662-49886-6
⢠Mark Pilgrim, Florian Wollenschein: Python 3 â Intensivkurs. 1. Auflage. Springer, 2010, ISBN 978-3-642-04376-5 (Deutsche Ăbersetzung von Dive Into Python 3 google-books)
⢠Mark Pilgrim: Dive Into Python 3. 2. Auflage. Springer, 2009, ISBN 1-4302-2415-0 (Download verfßgbar)
⢠John Paul Mueller: Python programmieren lernen fßr Dummies. 2. Auflage. Wiley, Weinheim 2018, ISBN 978-3-527-71490-2, S. 407 (bei der Deutschen Nationalbibliothek).
⢠Martina GlÜde (Hrsg.): Programmieren supereasy. Einfacher Einstieg in Scratch und Python. Dorling Kindersley, Mßnchen 2020, ISBN 978-3-8310-3961-6, S. 224.
⢠Warren D. Sande; Carter Sande: Hello World! Programmieren fßr Kids und andere Anfänger. 2., akt. u. erw. Auflage. Hanser, Mßnchen 2014, ISBN 978-3-446-43806-4, S. 475.
⢠Michael Bonacina: Python 3 Programmieren fßr Einsteiger: Der leichte Weg zum Python-Experten, 2. Auflage. BMU Verlag, Landshut 2019, ISBN 978-3-96645-007-2.
Referenzen
⢠Michael Weigend: Python ge-packt. 8. Auflage. mitp, Frechen 2020, ISBN 978-3-7475-0194-8, S. 656.
⢠Johannes Ernesti; Peter Kaiser: Python 3. Das umfassende Handbuch. 7., aktualisierte Auflage. Rheinwerk, Bonn 2023, ISBN 978-3-8362-9129-3 (rheinwerk-verlag.de â OpenBook beim Verlag (5. Auflage)).
⢠Mark Lutz: Python. Kurz & gut. 5. Auflage. OâReilly, KĂśln u. a. 2014, ISBN 978-3-95561-770-7, S. 270.
WeiterfĂźhrendes
⢠Luciano Ramalho: Fluent Python. Clear, concise, and effective programming. 2. Auflage. OâReilly, Sebastopol CA u. a. 2022, ISBN 978-1-4920-5635-5, S. 983.
⢠Gregor Lingl: Python fßr Kids. 4. Auflage. bhv, 2010, ISBN 3-8266-8673-X.
⢠Farid Hajji: Das Python-Praxisbuch. 1. Auflage. Addison-Wesley, 2008, ISBN 978-3-8273-2543-3.
⢠Hans P. Langtangen: Python Scripting for Computational Science. 3. Auflage. Springer, 2008, ISBN 3-540-43508-5.
⢠Michael Weigend: Objektorientierte Programmierung mit Python. mitp-Verlag, 1. Auflage 2006, ISBN 3-8266-0966-2.
⢠Felix Bittmann: Praxishandbuch Python 3. Konzepte der Programmierung verstehen und anwenden. 1. Auflage. Books on Demand, Norderstedt 2020, ISBN 978-3-7519-0058-4, S. 240 (Inhaltsverzeichnis).
Weblinks
Commons
: Python
â Sammlung von Bildern, Videos und Audiodateien
Wikibooks: Python 2 unter Linux
â Lern- und Lehrmaterialien
⢠Offizielle Website (englisch)
⢠CultRepo: Python: The Documentary - An origin story auf YouTube, 28. August 2025 (Dokumentarfilm ßber die Ursprßnge der Programmiersprache Python mit ausfßhrlichen Interviews mit u. a. Guido van Rossum; Laufzeit: 84:05 min).
Tutorials
Fßr Anfänger
⢠Python Examples (englisch)
⢠Online-Kurse und Tutorials fßr Python 2 und 3. Python-Kurs.eu
⢠Online-Kurs. University of Waterloo (deutsch, englisch, franzÜsisch)
⢠Practical programming for total beginners. Automate the Boring Stuff with Python (englisch)
⢠Einstieg in Python, Michael Weigend (deutsch)
⢠Python: Grafische Benutzeroberflächen fßr Python-Skripte erstellen, Veikko Krypczyk (deutsch)
FĂźr Fortgeschrittene
⢠PythonProgramming.net: Python-Tutorials fßr Data analysis, Machine learning & GUIs (englisch)
⢠PyData: Python-Vorträge und -Tutorials fßr Data analysis, Machine learning etc. (englisch)
⢠Awesome Python: Liste von Frameworks, Bibliotheken und Ressourcen, nach Themen gegliedert (englisch)
⢠Python 3 â Das umfassende Handbuch: Rheinwerk openbook zu Python 3 (deutsch)
FĂźr Kinder
⢠Snake Wrangling for Kids â Learning to Program with Python von Jason R. Briggs, fĂźr Kinder ab acht Jahren (englisch)
⢠Schlangengerangel fĂźr Kinder â Programmieren Lernen fĂźr Kinder (PDF; 2,1 MB) fĂźr Kinder ab acht Jahren (deutsch)
Einzelnachweise
cite-note-83139be75f1555ed-11. History and License - Python documentation. (abgerufen am 19. August 2016).
cite-note-6a6ea5617189f372-22. History and License - Python documentation. (abgerufen am 3. Juli 2019).
cite-note-2e3ef5c840860e7b-33. Python 3.15.0 alpha 2. 19. November 2025 (abgerufen am 3. Dezember 2025).
cite-note-f6a2446c4eafdb42-44. Why was Python created in the first place? Python Software Foundation (abgerufen am 22. März 2017).
cite-note-d78ce4f194f4bab5-55. impythonist.wordpress.com. (abgerufen am 19. August 2016).
cite-note-5db25f37ce6820c1-66. Classes The Python Tutorial. Python Software Foundation.
cite-note-6da19e7d2132b8e1-77. An Introduction to Python for UNIX/C Programmers.
cite-note-520bea055a144736-88. peps.python.org.
cite-note-79611fc4be4fe702-99. docs.python.org.
cite-note-edc84ae2b0444b77-1010. Functional Programming HOWTO.
cite-note-c93eab06d10d0117-1111. docs.python.org.
cite-note-a8542958924b9e3d-1212. Download Python.
cite-note-a0742d213c1fe180-1313. History and License - Python documentation.
cite-note-1414. â What is Python Good For? In: General Python FAQ. Python Foundation, abgerufen am 5. September 2008 (englisch).
cite-note-1515. â What is Python? Executive Summary. In: Python documentation. Python Foundation, abgerufen am 21. März 2007 (englisch).
cite-note-1616. â Offizielle Python FAQ, sowie Python Tutorial, Kapitel 1
cite-note-1717. â The Cobra Programming Language. In: cobra-language.com. Abgerufen im 1. Januar 1 (englisch).
cite-note-1818. â Boa Constructor home. In: boa-constructor.sourceforge.net. Abgerufen im 1. Januar 1 (englisch).
cite-note-1919. â Guido van Rossum: Kommentar zur Entfernung einiger funktionaler Konzepte. Abgerufen am 11. August 2014 (englisch).
cite-note-2020. â A. Kuchling, Moshe Zadka: Dokumentation Python 2.0. Python Software Foundation, abgerufen am 11. August 2014 (englisch).
cite-note-2121. â Guido van Rossum: Dokumentation Python 3.0. Python Software Foundation, 14. Februar 2009, abgerufen am 11. August 2014 (englisch).
cite-note-timeline-of-python-2214. Guido van Rossum: A Brief Timeline of Python. 20. Januar 2009, abgerufen am 29. November 2019 (englisch).
cite-note-releases-2315. Releases | Python.org. Abgerufen am 29. November 2019 (englisch).
cite-note-pep-0160-2416. Fred L. Jr. Drake: PEP 160 â Python 1.6 Release Schedule. 25. Juli 2000, abgerufen am 29. November 2019 (englisch).
cite-note-downloads-2517. Download Python | Python.org. Abgerufen am 29. November 2019 (englisch).
cite-note-pep-0200-2618. Jeremy Hylton: PEP 200 â Python 2.0 Release Schedule. Abgerufen am 29. November 2019 (englisch).
cite-note-pep-0226-2719. Jeremy Hylton: PEP 226 â Python 2.1 Release Schedule. 16. Oktober 2000, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0251-2820. Barry Warsaw, Guido van Rossum: PEP 251 â Python 2.2 Release Schedule. 17. April 2001, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0283-2921. Guido van Rossum: PEP 283 â Python 2.3 Release Schedule. 27. Februar 2002, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0320-3022. Barry Warsaw, Raymond Hettinger, Anthony Baxter: PEP 320 â Python 2.4 Release Schedule. 29. Juli 2003, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0356-3123. Neal Norwitz, Guido van Rossum, Anthony Baxter: PEP 356 â Python 2.5 Release Schedule. 7. Februar 2006, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0361-3224. Neal Norwitz, Barry Warsaw: PEP 361 â Python 2.6 and 3.0 Release Schedule. 29. Juni 2006, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0373-3325. Benjamin Peterson: PEP 373 â Python 2.7 Release Schedule. 3. November 2008, abgerufen am 20. April 2020 (englisch).
cite-note-devcycle-3426. 17. Development Cycle â Python Developer's Guide. Abgerufen am 29. November 2019 (englisch).
cite-note-pep-0375-3527. Benjamin Peterson: PEP 375 â Python 3.1 Release Schedule. 8. Februar 2009, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0392-3628. Georg Brandl: PEP 392 â Python 3.2 Release Schedule. 30. Dezember 2009, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0398-3729. Georg Brandl: PEP 398 â Python 3.3 Release Schedule. 23. März 2011, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0429-3830. Larry Hastings: PEP 429 â Python 3.4 Release Schedule. 17. Oktober 2012, abgerufen am 29. November 2019 (englisch).
cite-note-pep-0478-3931. Larry Hastings: PEP 478 â Python 3.5 Release Schedule. 22. September 2014, abgerufen am 17. März 2020 (englisch).
cite-note-pep-0494-4032. Ned Deily: PEP 494 â Python 3.6 Release Schedule. 30. Mai 2015, abgerufen am 23. Mai 2022 (englisch).
cite-note-pep-0537-4133. Ned Deily: PEP 537 â Python 3.7 Release Schedule. 23. Dezember 2016, abgerufen am 1. Februar 2023 (englisch).
cite-note-pep-0569-4234. Ĺukasz Langa: PEP 569 â Python 3.8 Release Schedule. 27. Januar 2018, abgerufen am 27. Dezember 2024 (englisch).
cite-note-pep-0596-4335. Ĺukasz Langa: PEP 596 â Python 3.9 Release Schedule. 13. Oktober 2020, abgerufen am 27. Dezember 2024 (englisch).
cite-note-pep-0619-4436. Pablo Salgado: PEP 619 â Python 3.10 Release Schedule. 25. Mai 2020, abgerufen am 27. Dezember 2024 (englisch).
cite-note-pep-0664-4537. Pablo Salgado: PEP 664 â Python 3.11 Release Schedule. 12. Juli 2021, abgerufen am 27. Dezember 2024 (englisch).
cite-note-4638. Thomas Wouters: PEP 693 â Python 3.12 Release Schedule. 24. Mai 2022, abgerufen am 27. Dezember 2024 (englisch).
cite-note-4739. Thomas Wouters: PEP 719 â Python 3.13 Release Schedule. 26. Mai 2023, abgerufen am 27. Dezember 2024 (englisch).
cite-note-4840. Hugo van Kemenade: PEP 745 â Python 3.14 Release Schedule. 24. April 2024, abgerufen am 27. Dezember 2024 (englisch).
cite-note-4949. â 2. Lexical analysis. Abgerufen am 13. Dezember 2024 (englisch).
cite-note-5050. â Marty Alchin: Pro Python. Hrsg.: Apress. 2010, ISBN 978-1-4302-2757-1, S. 6 (englisch).
cite-note-5151. â Bill Venners: Interview mit Guido van Rossum. Artima, 13. Januar 2003, abgerufen am 15. August 2014 (englisch).
cite-note-5252. â Verwendung fremdsprachiger Module. In: Python. Python Software Foundation, abgerufen am 8. August 2023 (englisch).
cite-note-5353. â Guido van Rossum, Ivan Levkivskyi: PEP 483 â The Theory of Type Hints. Python Software Foundation, 19. Dezember 2014, abgerufen am 18. Oktober 2020 (englisch).
cite-note-5454. â Guido van Rossum, Jukka Lehtosalo, Ĺukasz Langa: PEP 484 â Type Hints. Python Software Foundation, 29. September 2014, abgerufen am 18. Oktober 2020 (englisch).
cite-note-5555. â Mark Lutz, David Ascher: Learning Python, 2nd Edition. In: Safari Books Online. 23. Dezember 2003; abgerufen im 1. Januar 1 (englisch).
cite-note-5656. â Design and History FAQ â Python 3 documentation. Abgerufen am 7. Juli 2024.
cite-note-5757. â Coconut (Erweiterung zu Python)
cite-note-5858. â Pyston. Python Performance. Abgerufen am 18. September 2022.
cite-note-5959. â MicroPython â Python for microcontrollers. In: micropython.org. Abgerufen im 1. Januar 1 (englisch).
cite-note-6060. â Python â IntelliJ IDEA. In: jetbrains.com. 8. März 2021, abgerufen am 14. Januar 2023 (englisch).
cite-note-6161. â Conda documentation. Abgerufen am 25. Februar 2016 (englisch).
cite-note-6262. â Quotes about Python. Abgerufen am 25. Juni 2011.
cite-note-6363. â Computer Science Circles â ein kostenfreier Dienst des Centre for Education in Mathematics and Computing, University of Waterloo.
cite-note-6464. â Programmieren lernen mit Python. App Camps gemeinnĂźtzige Unternehmergesellschaft, Hamburg
cite-note-6565. â Programming for Data Science with Python, Udacity
cite-note-6666. â Einstieg ins Programmieren mit Python. Web 2 Unterricht, 3. September 2017
cite-note-6767. â Python â die Programmiersprache fĂźr imperative und objektorientierte Programmierung. Bildungsserver Berlin-Brandenburg
cite-note-6868. â Programmieren mit Python. Bildungsserver Rheinland-Pfalz
cite-note-6969. â Man vergleiche z. B. Programmieren supereasy â Einfacher Einstieg in Scratch und Python. von Carol Vorderman und Jon Woodcock, Dorling Kindersley Verlag, oder Python 4 Kids von Gregor Lingl, Mitp Verlag
cite-note-7171. â Karin ZĂźhlke: Erstmals ÂťLive on stageÂŤ: Farnell zeigt den Raspberry Pi Nachwuchs. Abgerufen im 1. Januar 1 (englisch).
cite-note-7272. â Computer Science Circles | 01000011 01010011 01000011. Abgerufen am 19. November 2024 (deutsch).
cite-note-7373. â Flyer TigerJython â Programmierkonzepte mit Python (Memento vom 12. Juli 2021 im Internet Archive) (PDF; 468 kB) Pädagogischen Hochschule Bern
cite-note-7474. â Jupyter, Mathematica, and the Future of the Research Paper. paulromer.net, 13. April 2018, abgerufen am 12. Dezember 2019 (englisch).
cite-note-7575. â Benjamin Peterson: Python Insider: Python 2.7.18, the last release of Python 2. In: Python Insider. 20. April 2020, abgerufen am 12. Juli 2022 (englisch).
cite-note-7676. â Silke Hahn: Programmiersprachen: Lang lebe Python 3 â finales Release von Python 2. In: heise online. 21. April 2020, abgerufen am 12. Juli 2022.
cite-note-7777. â Python Software Foundation: Press Release 20-Dec-2019. Abgerufen am 12. Juli 2022 (englisch).
cite-note-7878. â Golem.de: IT-News fĂźr Profis. Abgerufen am 12. Juli 2022.
cite-note-7979. â Porting Python 2 Code to Python 3 â Python 3.7.13 documentation. Abgerufen am 12. Juli 2022.
cite-note-8080. â The Conservative Python 3 Porting Guide â Conservative Python 3 Porting Guide 1.0 documentation. Abgerufen am 12. Juli 2022.
cite-note-8181. â Lennart Regebro: Supporting Python 3 â Supporting Python 3: An in-depth guide. Abgerufen am 12. Juli 2022 (englisch).
cite-note-8282. â 25.4. 2to3 â Automated Python 2 to 3 code translation â Python 2.7.18 documentation. Abgerufen am 12. Juli 2022.
cite-note-8383. â six: pypi.python.org und Archivierte Kopie (Memento vom 8. Januar 2019 im Internet Archive)
cite-note-8484. â Python-Modernize â modernize 0.6.1 documentation. Abgerufen am 12. Juli 2022.
cite-note-8585. â Easy, clean, reliable Python 2/3 compatibility â Python-Future documentation. Abgerufen am 12. Juli 2022.
cite-note-8686. â Victor Stinner: sixer: Add Python 3 support to Python 2 applications using the six module. Abgerufen am 12. Juli 2022.
cite-note-8787. â limodou: 2to6. 25. Juni 2019, abgerufen am 12. Juli 2022.
cite-note-8888. â A. M. Kuchling. Abgerufen am 1. September 2020 (englisch).
cite-note-9090. â Guido van Rossum: Why explicit self has to stay
cite-note-zen-9191. â Tim Peters: The Zen of Python. Python Software Foundation, 19. August 2004, abgerufen am 12. August 2014 (englisch).
cite-note-9292. â PEP 3135 â New Super. In: Python.org. Abgerufen im 1. Januar 1 (englisch).
cite-note-9393. â heise online: Python 3.13: Endlich effizienteres Multithreading ohne Global Interpreter Lock. 15. März 2024, abgerufen am 21. Mai 2024.
cite-note-9494. â Library and Extension FAQ â Python 3.7.0 documentation. In: Python.org. Abgerufen im 1. Januar 1 (englisch).
cite-note-9595. â Guido van van Rossum: It isnât Easy to Remove the GIL. In: Artima.com. Abgerufen im 1. Januar 1 (englisch).
cite-note-shootout-c-9696. â PythonâC. Archiviert vom Original am 26. Dezember 2015; abgerufen am 25. Dezember 2015 (englisch).
cite-note-shootout-perl-9797. â PythonâPerl. Archiviert vom Original am 26. Dezember 2015; abgerufen am 25. Dezember 2015 (englisch).
cite-note-shootout-php-1-9898. â Benchmark-Vergleich PythonâPHP. Archiviert vom Original am 26. Dezember 2015; abgerufen am 25. Dezember 2015 (englisch).
cite-note-shootout-php-2-9999. â Benchmark-Vergleich PythonâDart. Archiviert vom Original am 26. Dezember 2015; abgerufen am 25. Dezember 2015 (englisch).
cite-note-shootout-ruby-100100. â Benchmark-Vergleich PythonâRuby. Archiviert vom Original am 26. Dezember 2015; abgerufen am 25. Dezember 2015 (englisch).
cite-note-101101. â Python Culture. Archiviert vom Original am 28. Dezember 2009; abgerufen am 23. Dezember 2009 (englisch).
cite-note-102102. â Python Patterns â An Optimization Anecdote. In: Python.org. Abgerufen im 1. Januar 1 (englisch).